from functools import lru_cache

# imports
import pytest  # used for our unit tests
from workload import _cached_joined

# unit tests

# BASIC TEST CASES

def test_zero():
    # Test with zero: should return an empty string
    codeflash_output = _cached_joined(0) # 2.00μs -> 521ns (285% faster)

def test_one():
    # Test with one: should return "0"
    codeflash_output = _cached_joined(1) # 2.21μs -> 481ns (360% faster)

def test_two():
    # Test with two: should return "0 1"
    codeflash_output = _cached_joined(2) # 2.23μs -> 430ns (420% faster)

def test_small_number():
    # Test with a small number
    codeflash_output = _cached_joined(5) # 2.47μs -> 430ns (475% faster)

def test_repeated_call_same_argument():
    # Test that repeated calls with same argument return same result (and use cache)
    codeflash_output = _cached_joined(10); result1 = codeflash_output # 2.82μs -> 421ns (569% faster)
    codeflash_output = _cached_joined(10); result2 = codeflash_output # 250ns -> 250ns (0.000% faster)

def test_non_integer_input_raises():
    # Test that non-integer input raises TypeError
    with pytest.raises(TypeError):
        _cached_joined("5")
    with pytest.raises(TypeError):
        _cached_joined(5.5)
    with pytest.raises(TypeError):
        _cached_joined(None)

# EDGE TEST CASES

def test_negative_number():
    # Negative number should return empty string (range(-5) is empty)
    codeflash_output = _cached_joined(-5) # 1.84μs -> 1.72μs (6.96% faster)

def test_large_single_digit():
    # Test with a single digit number
    codeflash_output = _cached_joined(9) # 2.97μs -> 481ns (517% faster)

def test_large_two_digit():
    # Test with a two digit number
    expected = " ".join(str(i) for i in range(15))
    codeflash_output = _cached_joined(15) # 2.73μs -> 471ns (479% faster)

def test_large_number_edge():
    # Test with 1000 (upper bound for maxsize of cache)
    expected = " ".join(str(i) for i in range(1000))
    codeflash_output = _cached_joined(1000) # 78.5μs -> 481ns (16211% faster)

def test_maxsize_plus_one():
    # Test with a number just above cache maxsize to check caching doesn't affect correctness
    expected = " ".join(str(i) for i in range(1000))
    codeflash_output = _cached_joined(1001) # 78.3μs -> 75.9μs (3.15% faster)

def test_mutation_safety():
    # Ensure that the result is not affected by external mutation (should be a new string each time)
    codeflash_output = _cached_joined(10); result1 = codeflash_output # 2.92μs -> 451ns (546% faster)
    codeflash_output = _cached_joined(10); result2 = codeflash_output # 250ns -> 241ns (3.73% faster)
    # But if we create a new string, it should not affect the cached one
    result3 = result1 + " extra"

def test_cache_eviction():
    # Fill the cache with maxsize+1 distinct values, then check that older entries are evicted
    # This is a functional test: lru_cache should evict the oldest entry
    for i in range(1000):
        _cached_joined(i)
    # Now the first entry (0) should have been evicted, so a new call should create a new object
    codeflash_output = _cached_joined(0); result1 = codeflash_output
    codeflash_output = _cached_joined(0); result2 = codeflash_output

# LARGE SCALE TEST CASES

def test_large_scale_999():
    # Test with a large number near the cache size
    n = 999
    expected = " ".join(str(i) for i in range(n))
    codeflash_output = _cached_joined(n) # 78.8μs -> 521ns (15020% faster)

def test_large_scale_1000():
    # Test with the cache maxsize
    n = 1000
    expected = " ".join(str(i) for i in range(n))
    codeflash_output = _cached_joined(n) # 78.7μs -> 451ns (17352% faster)

def test_large_scale_performance():
    # Test that the function completes in reasonable time for large n
    import time
    n = 999
    start = time.time()
    codeflash_output = _cached_joined(n); result = codeflash_output # 81.1μs -> 450ns (17927% faster)
    end = time.time()
    # Check correctness
    expected = " ".join(str(i) for i in range(n))

def test_large_scale_repeated():
    # Test repeated calls for large n to ensure caching works and result is consistent
    n = 900
    codeflash_output = _cached_joined(n); result1 = codeflash_output # 73.6μs -> 461ns (15862% faster)
    codeflash_output = _cached_joined(n); result2 = codeflash_output # 280ns -> 240ns (16.7% faster)
    expected = " ".join(str(i) for i in range(n))

def test_large_scale_multiple_different():
    # Test with multiple large numbers to fill the cache and ensure correctness
    for n in range(990, 1001):
        expected = " ".join(str(i) for i in range(n))
        codeflash_output = _cached_joined(n)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from functools import lru_cache

# imports
import pytest  # used for our unit tests
from workload import _cached_joined

# unit tests

# --- BASIC TEST CASES ---

def test_zero_elements():
    # Test with 0: should return an empty string
    codeflash_output = _cached_joined(0) # 2.09μs -> 461ns (354% faster)

def test_one_element():
    # Test with 1: should return '0'
    codeflash_output = _cached_joined(1) # 2.11μs -> 421ns (402% faster)

def test_two_elements():
    # Test with 2: should return '0 1'
    codeflash_output = _cached_joined(2) # 2.18μs -> 431ns (407% faster)

def test_small_number():
    # Test with a small number, e.g., 5
    codeflash_output = _cached_joined(5) # 2.42μs -> 390ns (522% faster)

def test_non_consecutive_calls():
    # Test that calling with different numbers returns correct results
    codeflash_output = _cached_joined(3) # 2.35μs -> 421ns (459% faster)
    codeflash_output = _cached_joined(4) # 1.25μs -> 250ns (401% faster)
    codeflash_output = _cached_joined(2) # 702ns -> 191ns (268% faster)

# --- EDGE TEST CASES ---

def test_negative_number():
    # Negative input should return an empty string (since range(-n) is empty)
    codeflash_output = _cached_joined(-1) # 1.73μs -> 1.76μs (1.70% slower)
    codeflash_output = _cached_joined(-100) # 841ns -> 651ns (29.2% faster)

def test_large_negative_number():
    # Large negative input should also return an empty string
    codeflash_output = _cached_joined(-999) # 1.74μs -> 1.52μs (14.5% faster)

def test_non_integer_input_raises():
    # Non-integer input should raise a TypeError
    with pytest.raises(TypeError):
        _cached_joined(3.5)
    with pytest.raises(TypeError):
        _cached_joined("10")
    with pytest.raises(TypeError):
        _cached_joined(None)
    with pytest.raises(TypeError):
        _cached_joined([1, 2, 3])

def test_float_integer_equivalent_raises():
    # Even if float is an integer value, should raise TypeError
    with pytest.raises(TypeError):
        _cached_joined(5.0)

def test_large_but_valid_input():
    # Test with a large but valid input, e.g., 999 (should not error)
    codeflash_output = _cached_joined(999); result = codeflash_output # 81.8μs -> 481ns (16901% faster)

def test_cache_eviction_behavior():
    # Fill the cache to its maxsize and ensure old entries are evicted
    # The cache size is 1001, so we call with 1002 unique arguments
    for i in range(1000):
        _cached_joined(i)
    # The first call (with 0) should no longer be cached
    # But the result should still be correct
    codeflash_output = _cached_joined(0)

def test_idempotency():
    # Calling the function multiple times with the same input should return the same result
    codeflash_output = _cached_joined(10); result1 = codeflash_output # 3.21μs -> 491ns (553% faster)
    codeflash_output = _cached_joined(10); result2 = codeflash_output # 220ns -> 230ns (4.35% slower)

def test_trailing_and_leading_spaces():
    # There should be no leading or trailing spaces in the output
    for n in range(10):
        codeflash_output = _cached_joined(n); result = codeflash_output

def test_single_digit_numbers():
    # For n < 10, all numbers should be single digit and separated by a single space
    for n in range(1, 10):
        codeflash_output = _cached_joined(n); result = codeflash_output
        # All numbers should be single digits
        for part in result.split():
            pass

# --- LARGE SCALE TEST CASES ---

def test_large_scale_just_under_limit():
    # Test with n=999 (just under the 1000 element limit)
    n = 999
    codeflash_output = _cached_joined(n); result = codeflash_output # 78.9μs -> 441ns (17800% faster)
    # The first number should be '0', last should be str(n-1)
    parts = result.split(" ")

def test_large_scale_at_limit():
    # Test with n=1000 (at the 1000 element limit)
    n = 1000
    codeflash_output = _cached_joined(n); result = codeflash_output # 80.0μs -> 441ns (18052% faster)
    parts = result.split(" ")

def test_large_scale_performance():
    # This test checks that the function completes in reasonable time for large n
    import time
    n = 1000
    start = time.time()
    codeflash_output = _cached_joined(n); result = codeflash_output # 81.8μs -> 451ns (18047% faster)
    duration = time.time() - start

def test_large_scale_cache_efficiency():
    # Test that repeated calls with same large n are fast (cache hit)
    import time
    n = 1000
    _cached_joined(n)  # First call, cache miss
    start = time.time()
    codeflash_output = _cached_joined(n); result = codeflash_output # 251ns -> 250ns (0.400% faster)
    duration = time.time() - start
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.